{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "[toc]\n",
    "\n",
    "---\n",
    "# 数组的创建\n",
    "\n",
    "导入 numpy。\n",
    "\n",
    "```\n",
    "import numpy as np\n",
    "```\n",
    "\n",
    "numpy 提供的最重要的数据结构是`ndarray`，它是 python 中`list`的扩展。\n",
    "\n",
    "## 1. 依据现有数据来创建 ndarray\n",
    "\n",
    "### **（a）通过array()函数进行创建。**\n",
    "\n",
    "```python\n",
    "def array(p_object, dtype=None, copy=True, order='K', subok=False, ndmin=0): \n",
    "``` \n",
    "\n",
    "\n",
    "【例】\n",
    "```python\n",
    "import numpy as np\n",
    "\n",
    "# 创建一维数组\n",
    "a = np.array([0, 1, 2, 3, 4])\n",
    "b = np.array((0, 1, 2, 3, 4))\n",
    "print(a, type(a))\n",
    "# [0 1 2 3 4] <class 'numpy.ndarray'>\n",
    "print(b, type(b))\n",
    "# [0 1 2 3 4] <class 'numpy.ndarray'>\n",
    "\n",
    "# 创建二维数组\n",
    "c = np.array([[11, 12, 13, 14, 15],\n",
    "              [16, 17, 18, 19, 20],\n",
    "              [21, 22, 23, 24, 25],\n",
    "              [26, 27, 28, 29, 30],\n",
    "              [31, 32, 33, 34, 35]])\n",
    "print(c, type(c))\n",
    "# [[11 12 13 14 15]\n",
    "#  [16 17 18 19 20]\n",
    "#  [21 22 23 24 25]\n",
    "#  [26 27 28 29 30]\n",
    "#  [31 32 33 34 35]] <class 'numpy.ndarray'>\n",
    "\n",
    "# 创建三维数组\n",
    "d = np.array([[(1.5, 2, 3), (4, 5, 6)],\n",
    "              [(3, 2, 1), (4, 5, 6)]])\n",
    "print(d, type(d))\n",
    "# [[[1.5 2.  3. ]\n",
    "#   [4.  5.  6. ]]\n",
    "#\n",
    "#  [[3.  2.  1. ]\n",
    "#   [4.  5.  6. ]]] <class 'numpy.ndarray'>\n",
    "```\n",
    "\n",
    "### **（b）通过asarray()函数进行创建**\n",
    "\n",
    "`array()`和`asarray()`都可以将结构数据转化为 ndarray，但是`array()`和`asarray()`主要区别就是当数据源是**ndarray** 时，`array()`仍然会 copy 出一个副本，占用新的内存，但不改变 dtype 时 `asarray()`不会。\n",
    "\n",
    "```python\n",
    "def asarray(a, dtype=None, order=None):\n",
    "    return array(a, dtype, copy=False, order=order)\n",
    "```\n",
    "\n",
    "【例】`array()`和`asarray()`都可以将结构数据转化为 ndarray\n",
    "```python\n",
    "import numpy as np\n",
    "\n",
    "x = [[1, 1, 1], [1, 1, 1], [1, 1, 1]]\n",
    "y = np.array(x)\n",
    "z = np.asarray(x)\n",
    "x[1][2] = 2\n",
    "print(x,type(x))\n",
    "# [[1, 1, 1], [1, 1, 2], [1, 1, 1]] <class 'list'>\n",
    "\n",
    "print(y,type(y))\n",
    "# [[1 1 1]\n",
    "#  [1 1 1]\n",
    "#  [1 1 1]] <class 'numpy.ndarray'>\n",
    "\n",
    "print(z,type(z))\n",
    "# [[1 1 1]\n",
    "#  [1 1 1]\n",
    "#  [1 1 1]] <class 'numpy.ndarray'>\n",
    "```\n",
    "\n",
    "【例】`array()`和`asarray()`的区别。(`array()`和`asarray()`主要区别就是当数据源是**ndarray** 时，`array()`仍然会 copy 出一个副本，占用新的内存，但不改变 dtype 时 `asarray()`不会。)\n",
    "```python\n",
    "import numpy as np\n",
    "\n",
    "x = np.array([[1, 1, 1], [1, 1, 1], [1, 1, 1]])\n",
    "y = np.array(x)\n",
    "z = np.asarray(x)\n",
    "w = np.asarray(x, dtype=np.int)\n",
    "x[1][2] = 2\n",
    "print(x,type(x),x.dtype)\n",
    "# [[1 1 1]\n",
    "#  [1 1 2]\n",
    "#  [1 1 1]] <class 'numpy.ndarray'> int32\n",
    "\n",
    "print(y,type(y),y.dtype)\n",
    "# [[1 1 1]\n",
    "#  [1 1 1]\n",
    "#  [1 1 1]] <class 'numpy.ndarray'> int32\n",
    "\n",
    "print(z,type(z),z.dtype)\n",
    "# [[1 1 1]\n",
    "#  [1 1 2]\n",
    "#  [1 1 1]] <class 'numpy.ndarray'> int32\n",
    "\n",
    "print(w,type(w),w.dtype)\n",
    "# [[1 1 1]\n",
    "#  [1 1 2]\n",
    "#  [1 1 1]] <class 'numpy.ndarray'> int32\n",
    "```\n",
    "\n",
    "\n",
    "【例】更改为较大的dtype时，其大小必须是array的最后一个axis的总大小（以字节为单位）的除数\n",
    "```python\n",
    "import numpy as np\n",
    "\n",
    "x = np.array([[1, 1, 1], [1, 1, 1], [1, 1, 1]])\n",
    "print(x, x.dtype)\n",
    "# [[1 1 1]\n",
    "#  [1 1 1]\n",
    "#  [1 1 1]] int32\n",
    "x.dtype = np.float\n",
    "\n",
    "# ValueError: When changing to a larger dtype, its size must be a divisor of the total size in bytes of the last axis of the array.\n",
    "```\n",
    "\n",
    "### **（c）通过fromfunction()函数进行创建**\n",
    "\n",
    "给函数绘图的时候可能会用到`fromfunction()`，该函数可从函数中创建数组。\n",
    "\n",
    "```python\n",
    "def fromfunction(function, shape, **kwargs):\n",
    "```\n",
    "\n",
    "\n",
    "【例】通过在每个坐标上执行一个函数来构造数组。\n",
    "\n",
    "```python\n",
    "import numpy as np\n",
    "\n",
    "def f(x, y):\n",
    "    return 10 * x + y\n",
    "\n",
    "x = np.fromfunction(f, (5, 4), dtype=int)\n",
    "print(x)\n",
    "# [[ 0  1  2  3]\n",
    "#  [10 11 12 13]\n",
    "#  [20 21 22 23]\n",
    "#  [30 31 32 33]\n",
    "#  [40 41 42 43]]\n",
    "\n",
    "x = np.fromfunction(lambda i, j: i == j, (3, 3), dtype=int)\n",
    "print(x)\n",
    "# [[ True False False]\n",
    "#  [False  True False]\n",
    "#  [False False  True]]\n",
    "\n",
    "x = np.fromfunction(lambda i, j: i + j, (3, 3), dtype=int)\n",
    "print(x)\n",
    "# [[0 1 2]\n",
    "#  [1 2 3]\n",
    "#  [2 3 4]]\n",
    "```\n",
    "\n",
    "\n",
    "\n",
    "## 2. 依据 ones 和 zeros 填充方式\n",
    "\n",
    "在机器学习任务中经常做的一件事就是初始化参数，需要用常数值或者随机值来创建一个固定大小的矩阵。\n",
    "\n",
    "### **（a）零数组**\n",
    "\n",
    "- `zeros()`函数：返回给定形状和类型的零数组。\n",
    "- `zeros_like()`函数：返回与给定数组形状和类型相同的零数组。\n",
    "\n",
    "```python\n",
    "def zeros(shape, dtype=None, order='C'):\n",
    "def zeros_like(a, dtype=None, order='K', subok=True, shape=None):\n",
    "```\n",
    "\n",
    "【例】\n",
    "```python\n",
    "import numpy as np\n",
    "\n",
    "x = np.zeros(5)\n",
    "print(x)  # [0. 0. 0. 0. 0.]\n",
    "x = np.zeros([2, 3])\n",
    "print(x)\n",
    "# [[0. 0. 0.]\n",
    "#  [0. 0. 0.]]\n",
    "\n",
    "x = np.array([[1, 2, 3], [4, 5, 6]])\n",
    "y = np.zeros_like(x)\n",
    "print(y)\n",
    "# [[0 0 0]\n",
    "#  [0 0 0]]\n",
    "```\n",
    "\n",
    "### **（b）1数组**\n",
    "\n",
    "- `ones()`函数：返回给定形状和类型的1数组。\n",
    "- `ones_like()`函数：返回与给定数组形状和类型相同的1数组。\n",
    "\n",
    "```python\n",
    "def ones(shape, dtype=None, order='C'):\n",
    "def ones_like(a, dtype=None, order='K', subok=True, shape=None):\n",
    "```\n",
    "\n",
    "【例】\n",
    "```python\n",
    "import numpy as np\n",
    "\n",
    "x = np.ones(5)\n",
    "print(x)  # [1. 1. 1. 1. 1.]\n",
    "x = np.ones([2, 3])\n",
    "print(x)\n",
    "# [[1. 1. 1.]\n",
    "#  [1. 1. 1.]]\n",
    "\n",
    "x = np.array([[1, 2, 3], [4, 5, 6]])\n",
    "y = np.ones_like(x)\n",
    "print(y)\n",
    "# [[1 1 1]\n",
    "#  [1 1 1]]\n",
    "```\n",
    "\n",
    "### **（c）空数组**\n",
    "\n",
    "- `empty()`函数：返回一个空数组，数组元素为随机数。\n",
    "- `empty_like`函数：返回与给定数组具有相同形状和类型的新数组。\n",
    "\n",
    "```python\n",
    "def empty(shape, dtype=None, order='C'): \n",
    "def empty_like(prototype, dtype=None, order='K', subok=True, shape=None):\n",
    "```\n",
    "\n",
    "【例】\n",
    "```python\n",
    "import numpy as np\n",
    "\n",
    "x = np.empty(5)\n",
    "print(x)\n",
    "# [1.95821574e-306 1.60219035e-306 1.37961506e-306 \n",
    "#  9.34609790e-307 1.24610383e-306]\n",
    "\n",
    "x = np.empty((3, 2))\n",
    "print(x)\n",
    "# [[1.60220393e-306 9.34587382e-307]\n",
    "#  [8.45599367e-307 7.56598449e-307]\n",
    "#  [1.33509389e-306 3.59412896e-317]]\n",
    "\n",
    "x = np.array([[1, 2, 3], [4, 5, 6]])\n",
    "y = np.empty_like(x)\n",
    "print(y)\n",
    "# [[  7209029   6422625   6619244]\n",
    "#  [      100 707539280       504]]\n",
    "```\n",
    "\n",
    "### **（d）单位数组**\n",
    "\n",
    "- `eye()`函数：返回一个对角线上为1，其它地方为零的单位数组。\n",
    "- `identity()`函数：返回一个方的单位数组。\n",
    "\n",
    "```python\n",
    "def eye(N, M=None, k=0, dtype=float, order='C'):\n",
    "def identity(n, dtype=None):\n",
    "```\n",
    "\n",
    "\n",
    "【例】\n",
    "```python\n",
    "import numpy as np\n",
    "\n",
    "x = np.eye(4)\n",
    "print(x)\n",
    "# [[1. 0. 0. 0.]\n",
    "#  [0. 1. 0. 0.]\n",
    "#  [0. 0. 1. 0.]\n",
    "#  [0. 0. 0. 1.]]\n",
    "\n",
    "x = np.eye(2, 3)\n",
    "print(x)\n",
    "# [[1. 0. 0.]\n",
    "#  [0. 1. 0.]]\n",
    "\n",
    "x = np.identity(4)\n",
    "print(x)\n",
    "# [[1. 0. 0. 0.]\n",
    "#  [0. 1. 0. 0.]\n",
    "#  [0. 0. 1. 0.]\n",
    "#  [0. 0. 0. 1.]]\n",
    "```\n",
    "\n",
    "### **（e）对角数组**\n",
    "\n",
    "- `diag()`函数：提取对角线或构造对角数组。\n",
    "\n",
    "```python\n",
    "def diag(v, k=0):\n",
    "```\n",
    "\n",
    "【例】\n",
    "```python\n",
    "import numpy as np\n",
    "\n",
    "x = np.arange(9).reshape((3, 3))\n",
    "print(x)\n",
    "# [[0 1 2]\n",
    "#  [3 4 5]\n",
    "#  [6 7 8]]\n",
    "print(np.diag(x))  # [0 4 8]\n",
    "print(np.diag(x, k=1))  # [1 5]\n",
    "print(np.diag(x, k=-1))  # [3 7]\n",
    "\n",
    "v = [1, 3, 5, 7]\n",
    "x = np.diag(v)\n",
    "print(x)\n",
    "# [[1 0 0 0]\n",
    "#  [0 3 0 0]\n",
    "#  [0 0 5 0]\n",
    "#  [0 0 0 7]]\n",
    "```\n",
    "\n",
    "### **（f）常数数组**\n",
    "\n",
    "- `full()`函数：返回一个常数数组。\n",
    "- `full_like()`函数：返回与给定数组具有相同形状和类型的常数数组。\n",
    "\n",
    "```python\n",
    "def full(shape, fill_value, dtype=None, order='C'):\n",
    "def full_like(a, fill_value, dtype=None, order='K', subok=True, shape=None):\n",
    "```\n",
    "\n",
    "\n",
    "【例】\n",
    "```python\n",
    "import numpy as np\n",
    "\n",
    "x = np.full((2,), 7)\n",
    "print(x)\n",
    "# [7 7]\n",
    "\n",
    "x = np.full(2, 7)\n",
    "print(x)\n",
    "# [7 7]\n",
    "\n",
    "x = np.full((2, 7), 7)\n",
    "print(x)\n",
    "# [[7 7 7 7 7 7 7]\n",
    "#  [7 7 7 7 7 7 7]]\n",
    "\n",
    "x = np.array([[1, 2, 3], [4, 5, 6]])\n",
    "y = np.full_like(x, 7)\n",
    "print(y)\n",
    "# [[7 7 7]\n",
    "#  [7 7 7]]\n",
    "```\n",
    "\n",
    "\n",
    "\n",
    "## 3. 利用数值范围来创建ndarray\n",
    " - `arange()`函数：返回给定间隔内的均匀间隔的值。\n",
    " - `linspace()`函数：返回指定间隔内的等间隔数字。\n",
    " - `logspace()`函数：返回数以对数刻度均匀分布。\n",
    " - `numpy.random.rand()` 返回一个由[0,1)内的随机数组成的数组。\n",
    "\n",
    "```python\n",
    "def arange([start,] stop[, step,], dtype=None): \n",
    "def linspace(start, stop, num=50, endpoint=True, retstep=False, \n",
    "             dtype=None, axis=0):\n",
    "def logspace(start, stop, num=50, endpoint=True, base=10.0, \n",
    "             dtype=None, axis=0):\n",
    "def rand(d0, d1, ..., dn): \n",
    "```\n",
    "\n",
    "\n",
    "【例】\n",
    "```python\n",
    "import numpy as np\n",
    "\n",
    "x = np.arange(5)\n",
    "print(x)  # [0 1 2 3 4]\n",
    "\n",
    "x = np.arange(3, 7, 2)\n",
    "print(x)  # [3 5]\n",
    "\n",
    "x = np.linspace(start=0, stop=2, num=9)\n",
    "print(x)  \n",
    "# [0.   0.25 0.5  0.75 1.   1.25 1.5  1.75 2.  ]\n",
    "\n",
    "x = np.logspace(0, 1, 5)\n",
    "print(np.around(x, 2))\n",
    "# [ 1.    1.78  3.16  5.62 10.  ]            \n",
    "                                    #np.around 返回四舍五入后的值，可指定精度。\n",
    "                                   # around(a, decimals=0, out=None)\n",
    "                                   # a 输入数组\n",
    "                                   # decimals 要舍入的小数位数。 默认值为0。 如果为负，整数将四舍五入到小数点左侧的位置\n",
    "\n",
    "\n",
    "x = np.linspace(start=0, stop=1, num=5)\n",
    "x = [10 ** i for i in x]\n",
    "print(np.around(x, 2))\n",
    "# [ 1.    1.78  3.16  5.62 10.  ]\n",
    "\n",
    "x = np.random.random(5)\n",
    "print(x)\n",
    "# [0.41768753 0.16315577 0.80167915 0.99690199 0.11812291]\n",
    "\n",
    "x = np.random.random([2, 3])\n",
    "print(x)\n",
    "# [[0.41151858 0.93785153 0.57031309]\n",
    "#  [0.13482333 0.20583516 0.45429181]]\n",
    "```\n",
    "\n",
    "\n",
    "\n",
    "---\n",
    "## 4. 结构数组的创建\n",
    "\n",
    "结构数组，首先需要定义结构，然后利用`np.array()`来创建数组，其参数`dtype`为定义的结构。\n",
    "\n",
    "### **（a）利用字典来定义结构**\n",
    "\n",
    "【例】\n",
    "```python\n",
    "import numpy as np\n",
    "\n",
    "personType = np.dtype({\n",
    "    'names': ['name', 'age', 'weight'],\n",
    "    'formats': ['U30', 'i8', 'f8']})\n",
    "\n",
    "a = np.array([('Liming', 24, 63.9), ('Mike', 15, 67.), ('Jan', 34, 45.8)],\n",
    "             dtype=personType)\n",
    "print(a, type(a))\n",
    "# [('Liming', 24, 63.9) ('Mike', 15, 67. ) ('Jan', 34, 45.8)]\n",
    "# <class 'numpy.ndarray'>\n",
    "```\n",
    "\n",
    "### **（b）利用包含多个元组的列表来定义结构**\n",
    "\n",
    "【例】\n",
    "```python\n",
    "import numpy as np\n",
    "\n",
    "personType = np.dtype([('name', 'U30'), ('age', 'i8'), ('weight', 'f8')])\n",
    "a = np.array([('Liming', 24, 63.9), ('Mike', 15, 67.), ('Jan', 34, 45.8)],\n",
    "             dtype=personType)\n",
    "print(a, type(a))\n",
    "# [('Liming', 24, 63.9) ('Mike', 15, 67. ) ('Jan', 34, 45.8)]\n",
    "# <class 'numpy.ndarray'>\n",
    "\n",
    "# 结构数组的取值方式和一般数组差不多，可以通过下标取得元素：\n",
    "print(a[0])\n",
    "# ('Liming', 24, 63.9)\n",
    "\n",
    "print(a[-2:])\n",
    "# [('Mike', 15, 67. ) ('Jan', 34, 45.8)]\n",
    "\n",
    "# 我们可以使用字段名作为下标获取对应的值\n",
    "print(a['name'])\n",
    "# ['Liming' 'Mike' 'Jan']\n",
    "print(a['age'])\n",
    "# [24 15 34]\n",
    "print(a['weight'])\n",
    "# [63.9 67.  45.8]\n",
    "```\n",
    "\n",
    "---\n",
    "# 数组的属性\n",
    "\n",
    "在使用 numpy 时，你会想知道数组的某些信息。很幸运，在这个包里边包含了很多便捷的方法，可以给你想要的信息。\n",
    "\n",
    "\n",
    "\n",
    " - `numpy.ndarray.ndim`用于返回数组的维数（轴的个数）也称为秩，一维数组的秩为 1，二维数组的秩为 2，以此类推。\n",
    " - `numpy.ndarray.shape`表示数组的维度，返回一个元组，这个元组的长度就是维度的数目，即 `ndim` 属性(秩)。\n",
    " - `numpy.ndarray.size`数组中所有元素的总量，相当于数组的`shape`中所有元素的乘积，例如矩阵的元素总量为行与列的乘积。\n",
    " - `numpy.ndarray.dtype` `ndarray` 对象的元素类型。\n",
    " - `numpy.ndarray.itemsize`以字节的形式返回数组中每一个元素的大小。\n",
    "\n",
    "```python\n",
    "class ndarray(object):\n",
    "    shape = property(lambda self: object(), lambda self, v: None, lambda self: None)\n",
    "    dtype = property(lambda self: object(), lambda self, v: None, lambda self: None)\n",
    "    size = property(lambda self: object(), lambda self, v: None, lambda self: None)\n",
    "    ndim = property(lambda self: object(), lambda self, v: None, lambda self: None)\n",
    "    itemsize = property(lambda self: object(), lambda self, v: None, lambda self: None)\n",
    "```\n",
    "\n",
    "【例】\n",
    "```python\n",
    "import numpy as np\n",
    "\n",
    "a = np.array([1, 2, 3, 4, 5])\n",
    "print(a.shape)  # (5,)\n",
    "print(a.dtype)  # int32\n",
    "print(a.size)  # 5\n",
    "print(a.ndim)  # 1\n",
    "print(a.itemsize)  # 4\n",
    "\n",
    "b = np.array([[1, 2, 3], [4, 5, 6.0]])\n",
    "print(b.shape)  # (2, 3)\n",
    "print(b.dtype)  # float64\n",
    "print(b.size)  # 6\n",
    "print(b.ndim)  # 2\n",
    "print(b.itemsize)  # 8\n",
    "```\n",
    "\n",
    "在`ndarray`中所有元素必须是同一类型，否则会自动向下转换，`int->float->str`。\n",
    "\n",
    "【例】\n",
    "```python\n",
    "import numpy as np\n",
    "\n",
    "a = np.array([1, 2, 3, 4, 5])\n",
    "print(a)  # [1 2 3 4 5]\n",
    "b = np.array([1, 2, 3, 4, '5'])\n",
    "print(b)  # ['1' '2' '3' '4' '5']\n",
    "c = np.array([1, 2, 3, 4, 5.0])\n",
    "print(c)  # [1. 2. 3. 4. 5.]\n",
    "```\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.3"
  },
  "toc": {
   "base_numbering": 1,
   "nav_menu": {},
   "number_sections": true,
   "sideBar": true,
   "skip_h1_title": false,
   "title_cell": "Table of Contents",
   "title_sidebar": "Contents",
   "toc_cell": false,
   "toc_position": {
    "height": "calc(100% - 180px)",
    "left": "10px",
    "top": "150px",
    "width": "307.188px"
   },
   "toc_section_display": true,
   "toc_window_display": true
  },
  "varInspector": {
   "cols": {
    "lenName": 16,
    "lenType": 16,
    "lenVar": 40
   },
   "kernels_config": {
    "python": {
     "delete_cmd_postfix": "",
     "delete_cmd_prefix": "del ",
     "library": "var_list.py",
     "varRefreshCmd": "print(var_dic_list())"
    },
    "r": {
     "delete_cmd_postfix": ") ",
     "delete_cmd_prefix": "rm(",
     "library": "var_list.r",
     "varRefreshCmd": "cat(var_dic_list()) "
    }
   },
   "types_to_exclude": [
    "module",
    "function",
    "builtin_function_or_method",
    "instance",
    "_Feature"
   ],
   "window_display": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}
